<template>
  <div style="height:400px">
    <!--添加模块的meta-->
    <el-row>
      <el-col :span="3">
        <el-button style="" @click="start()">开始创建</el-button><br>
      </el-col>
      <el-col :span="3">
        <el-button style="" @click="deletaMeta()">删除模块信息</el-button>
      </el-col>
      <el-col :span="4">
        <el-input v-model="metaModuleId" placeholder="模块ID"></el-input>
      </el-col>
    </el-row>
    <hr>
    <el-scrollbar style="height: 300px;">
      <div
        v-for="(item, index) in myLog.info"
        :key="index"
        v-html="item.msg">
      </div>
    </el-scrollbar>
  </div>
</template>

<script>
/* eslint-disable import/no-absolute-path */
import { ref, reactive } from 'vue'
// 轻量级状态
import { state } from 'nf-state'

// 新 indexedDB
import { useDBHelp } from 'nf-web-storage'

export default {
  name: 'plat-meta-module-mod'
}

/**
 * 一个简单的记录执行过程和使用时间的 log
 */
class ShowLog {
  constructor () {
    this.info = reactive([])
  }

  newLog (title, count = 0) {
    this.info.push({
      title,
      msg: `<br>开始添加【${title}】...`,
      t1: window.performance.now(),
      t2: 0,
      item: []
    })
    if (count > 0) {
      this.info[this.info.length - 1].msg = `<br>开始添加【${title}】，共${count}个...`
    }
    return this.info.length - 1
  }

  start (msg = null, index = this.info.length - 1) {
    const _info = this.info[index]
    _info.t1 = window.performance.now()
    _info.msg += `<br>&nbsp;&nbsp;开始添加【${msg}】...`
  }

  end (id, index = this.info.length - 1) {
    const _info = this.info[index]
    _info.t2 = window.performance.now()
    _info.msg += `添加成功！ID：${id}。用时：${_info.t2 - _info.t1}`
    console.log(`===添加【${_info.title}】成功，表ID：${id}`)
  }

  clear () {
    this.info.length = 0
  }
}
/* eslint-disable camelcase */

/**
 * 创建meta
 */
const createMeta = (moduleInfo) => {
  // 进度提示信息
  const myLog = new ShowLog()

  // 记录表的ID
  let intTableId = parseInt(moduleInfo.tableModal.tableId) * 1000
  // 记录模块的ID
  let intModuleId = parseInt(moduleInfo.moduleModal.moduleId) * 100
  // 记录字段集合
  const cols = moduleInfo.columnModal
  // 记录字段的ID集合
  const colIds = []

  // indexedDB
  const sqlHelp = state.project_meta_sqlHelp
  // indexedDB 的 help
  const help = state.project_meta_dbHelp

  const {
    nf_table,
    nf_table_columns,
    nf_module,
    v_module_button,
    v_module_pager,
    v_module_grid,
    v_module_grid_item,
    v_module_find,
    v_module_find_item,
    v_module_form,
    v_module_form_item,
    v_service,
    v_service_action,
    v_service_model
  } = sqlHelp._tables

  // 【表、字段】的添加、修改=======================================
  const addTableSQL = async () => {
    // 表
    myLog.newLog('表')
    let res = await nf_table.add(moduleInfo.tableModal)
    myLog.end(res.newId)

    // 字段
    const logIndex = myLog.newLog('字段11', cols.length)
    for (let index = 0; index < cols.length; index++) {
      const col = cols[index]
      // cols.forEach(async (col, index) => {
      col.tableId = intTableId
      col.columnId = intTableId + (index + 1) * 10
      col.canNull = 0
      col.columnKind = index === 0 ? 11 : 14
      myLog.start(col.colName, logIndex)
      res = await nf_table_columns.add(col)
      myLog.end(res.newId, logIndex)
    } // )
  }

  // 【模块、分页】的添加、修改==========================================
  const _moduleId = 150
  const pagerId = 151
  /**
   * 菜单和分页，存入SQL，返回分页的 meta
   */
  const addModuleSQL = async () => {
    // 模块菜单
    myLog.newLog('模块菜单')
    let res = await nf_module.add(moduleInfo.moduleModal)
    myLog.end(res.newId)

    // 分页
    const pager = {
      moduleId: moduleInfo.moduleModal.moduleId, // 分页ID, int
      showCols: '', // 显示字段, 数组
      query: '', // 查询条件, 对象
      pageSize: 10, // 一页记录数, int
      pageTotal: 100, // 总记录数, int
      pageIndex: 1, // 第几页, int
      OrderColumns: 'id', // 排序字段, 对象
      fixedQuery: 'isDel = 0', // 固定查询条件, 对象
      fristQuery: '' // 首次查询条件, 对象
    }
    myLog.newLog('列表的分页')
    res = await v_module_pager.add(pager)
    myLog.end(res.newId)

    // 返回模块的分页信息
    return pager
  }

  // 模块的【操作按钮】
  const buttonId = 152
  /**
   * 操作按钮，存入SQL，返回按钮的 meta，对象形式
   */
  const addButtonSQL = async () => {
    const button = {
      moduleId: moduleInfo.moduleModal.moduleId, // 分页ID, int
      buttonId: 0, // 按钮ID, int
      btnTitle: '添加', // 按钮名称, varchar
      btnKind: 'add', // 按钮类型, varchar
      dialogTitle: '添加', // 弹窗名称, varchar
      dialogWidth: '50%', // 弹窗宽度, varchar
      controlKey: 'form', // 组件名称, varchar
      openModuleId: moduleInfo.moduleModal.moduleId, // 表单ID, int
      formMetaId: 10, // 表单的meta,
      actionId: 0, // actionId, int
      hotkey: 'a', // 快捷键, varchar
      disOrder: 0 // 排序, int
    }
    const reButton = {
      btnOrder: [],
      itemMeta: {},
      moduleId: moduleInfo.moduleModal.moduleId
    }
    const btns = [
      {
        btnTitle: '添加',
        btnKind: 'add',
        dialogTitle: '添加',
        dialogWidth: '50%',
        hotkey: 'a'
      },
      {
        btnTitle: '修改',
        btnKind: 'add',
        dialogTitle: '修改',
        dialogWidth: '50%',
        hotkey: 's'
      },
      {
        btnTitle: '删除',
        btnKind: 'delete',
        dialogTitle: '删除',
        dialogWidth: '50%',
        hotkey: 'd'
      }
    ]
    // 遍历添加
    const logIndex = myLog.newLog('列表的按钮')
    let res
    for (let index = 0; index < btns.length; index++) {
      const btn = btns[index]
      // arr.forEach(async (btn, index) => {
      button.buttonId += 10
      button.disOrder += 10
      button.actionId += 10
      // button.formMetaId += 10
      button.btnTitle = btn.btnTitle + moduleInfo.moduleModal.title
      button.btnKind = btn.btnKind
      button.dialogTitle = btn.dialogTitle + moduleInfo.moduleModal.title
      button.dialogWidth = btn.dialogWidth
      button.hotkey = btn.hotkey
      const newBtn = {}
      Object.assign(newBtn, button)
      reButton.btnOrder.push(button.buttonId)
      reButton.itemMeta[button.buttonId] = newBtn
      myLog.start(button.btnTitle, logIndex)
      res = await v_module_button.add(newBtn)
      myLog.end(res.newId, logIndex)
    } // )
    return reButton
  }

  // 模块列表的【列表、列表字段】的添加、修改
  const gridId = 153
  const gridItemId = 154
  /**
   * 列表和列表里的字段，存入SQL，返回列表的整体的 meta
   */
  const addGridSQL = async () => {
    const grid = {
      moduleId: moduleInfo.moduleModal.moduleId, // 分页ID, int
      idName: 'id', // 主键字段名, varhcar
      foreignIdName: '', // 外键字段名, varhcar
      height: 400, // 高度, int
      colOrder: colIds.join(','), // 显示字段, 数组
      stripe: 1, // 斑马纹, bit
      border: 1, // 纵向边框, bit
      fit: 1, // 是否自撑开, bit
      highlightCurrentRow: 1, // 要高亮当前行, bit
      // currentRowKey: '', // 当前行的 key, varhcar
      itemMeta: {} // 子组件属性, 对象
    }
    // 先检查有没有，没有——添加；有——修改/提示？
    const logIndex = myLog.newLog('列表')
    let res = await v_module_grid.add(grid)
    myLog.end(res.newId)

    // 列表的字段
    const item = {
      moduleId: moduleInfo.moduleModal.moduleId, // 模块ID, int
      columnId: 0, // 字段ID, int
      colName: '',
      label: 'cnName', // 标签, varhcar
      width: 120, // 宽度, int
      title: 'cnName', // 标题, varhcar
      align: 'left', // 内容对齐, tinyint
      headerAlign: 'center' // 标题对齐, tinyint
    }
    // 先检查有没有，没有——添加；有——修改/提示？
    for (let index = 0; index < cols.length; index++) {
      const col = cols[index]
      // cols.forEach(async (col, index) => { // 把表的字段都加入列表
      item.columnId = col.columnId
      item.colName = col.colName
      item.label = col.cnName
      item.title = col.cnName
      const newItem = {}
      Object.assign(newItem, item)
      grid.itemMeta[col.columnId] = newItem
      myLog.start('列表字段：' + item.colName, logIndex)
      res = await v_module_grid_item.add(newItem)
      myLog.end(res.newId, logIndex)
    } // )
    grid.colOrder = colIds
    return grid
  }

  // 模块列表的【表单、表单字段】的添加、修改
  const formId = 158
  const formItemId = 159
  const addFormSQL = async () => {
    const form = {
      moduleId: moduleInfo.moduleModal.moduleId, // 分页ID, int
      formId: intModuleId + 10, // 表单ID, int
      formColCount: 1, // 列数, int
      colOrder: colIds.join(','), // 字段ID集合, 数组
      formColShow: {}, // 组件联动, 对象
      ruleMeta: {}, // 验证规则, 对象
      itemMeta: {} // 子组件属性, 对象
    }
    // 先检查有没有，没有——添加；有——修改/提示？
    const logIndex = myLog.newLog('表单')
    let res = await v_module_form.add(form)
    myLog.end(res.newId)
    // 表单字段
    const item = {
      moduleId: moduleInfo.moduleModal.moduleId, // 模块ID, int
      formId: intModuleId + 10, // 表单ID, int
      columnId: 0, // 字段ID, int
      colName: 'colName', // 字段英文名
      label: 'cnName', // 字段中文名
      controlType: 101, // 控件类型
      defValue: '', // 默认值
      placeholder: 'cnName', // 占位符
      title: 'cnName', // 浮动提示
      extend: {} // 扩展属性
    }
    // 先检查有没有，没有——添加；有——修改/提示？
    for (let index = 0; index < cols.length; index++) {
      const col = cols[index]
      // cols.forEach(async (col, index) => { // 把表的字段都加入表单
      item.columnId = col.columnId
      item.controlType = col.controlType
      item.colName = col.colName
      item.label = col.cnName
      item.placeholder = col.placeholder
      item.title = col.cnName
      const newItem = {}
      myLog.start('表单字段：' + item.colName, logIndex)
      Object.assign(newItem, item)
      form.itemMeta[col.columnId] = newItem
      res = await v_module_form_item.add(newItem)
      myLog.end(res.newId, logIndex)
    } // )
    form.colOrder = colIds
    return form
  }

  // 模块列表的【查询、查询字段】的添加、修改
  const findId = 155
  const findItemId = 156
  const addFindSQL = async () => {
    const find = {
      moduleId: moduleInfo.moduleModal.moduleId, // 分页ID, int
      quickFind: colIds.join(','), // 快捷查询, 数组
      allFind: colIds.join(','), // 全部查询, 数组
      labelWidth: 100, // label宽度, int
      finditemWidth: 300, // 查询项宽度, int
      customer: {}, // 自定义查询, 对象
      customerDefault: 100, // 默认查询方案, int
      findKind: {}, // 查询方式, 对象
      itemMeta: {} // 子组件属性, 对象
    }
    // 先检查有没有，没有——添加；有——修改/提示？
    const logIndex = myLog.newLog('查询')
    let res = await v_module_find.add(find)
    myLog.end(res.newId)
    // 查询字段
    const item = {
      moduleId: moduleInfo.moduleModal.moduleId, // 模块ID, int
      columnId: 0, // 字段ID, int
      colName: 'colName', // 字段英文名
      label: 'cnName', // 字段中文名
      controlType: 101, // 控件类型
      defValue: '', // 默认值
      placeholder: 'cnName', // 占位符
      title: 'cnName', // 浮动提示
      extend: {} // 扩展属性
    }
    // 先检查有没有，没有——添加；有——修改/提示？
    const cols = moduleInfo.columnModal
    for (let index = 0; index < cols.length; index++) {
      const col = cols[index]
      // cols.forEach(async (col, index) => { // 把表的字段都加入表单
      item.columnId = col.columnId
      item.controlType = col.controlType
      item.colName = col.colName
      item.label = col.cnName
      item.placeholder = col.placeholder
      item.title = col.cnName
      const newItem = {}
      Object.assign(newItem, item)
      find.itemMeta[col.columnId] = newItem
      myLog.start('查询字段：' + item.colName, logIndex)
      res = await v_module_find_item.add(newItem)
      myLog.end(res.newId, logIndex)
    } // )
    find.quickFind = colIds
    find.allFind = colIds
    return find
  }

  // 模块列表的【后端service】的添加、修改===========================
  const serviceId = 165
  const addServiceSQL = async () => {
    const services = {
      serviceId: moduleInfo.moduleModal.moduleId, // 模块ID
      serviceName: '' // 服务名称
    }
    // 先检查有没有，没有——添加；有——修改/提示？
    myLog.newLog('后端service')
    const res = await v_service.add(services)
    myLog.end(res.newId)
    return services
  }

  // 模块列表的【后端model】的添加、修改
  const modelId = 167
  const addModelSQL = async () => {
    const model = {
      modelId: '10', // modelID int
      serviceId: moduleInfo.moduleModal.moduleId, // 模块ID
      modelName: '基础增删改查用', // model名称 varhcar
      tableNameId: moduleInfo.tableModal.tableId, // 表ID int
      tableName: moduleInfo.tableModal.tableName, // 表名 varhcar
      idKeyId: cols[0].columnId, // 字段ID int
      idKey: '', // 主键名称 varhcar
      colIds: [], // 需要的字段ID集合 数组
      cols: {}, // 需要的字段ID集合 数组
      pagerSize: 10, // 一页记录数 int
      orderBy: '{ "' + cols[0].columnId + '": false }' // 排序字段 varhcar
    }
    for (let index = 0; index < cols.length; index++) {
      const col = cols[index]
      // cols.forEach((col, index) => { // 把表的字段都加入表单
      model.colIds.push(col.columnId)
      model.cols[col.colName] = col.cnName
    } // )
    model.colIds = model.colIds.join(',')
    // 先检查有没有，没有——添加；有——修改/提示？
    myLog.newLog('后端model')
    const res = await v_service_model.add(model)
    myLog.end(res.newId)

    const model2 = {
      tableName: moduleInfo.tableModal.tableName,
      idKey: 'id',
      cols: {},
      pager: {
        pagerTotal: 100,
        pagerSize: 5,
        pagerIndex: 1,
        orderBy: '{ "moduleId": false }'
      }
    }
    // 加字段
    for (let index = 0; index < cols.length; index++) {
      const col = cols[index]
      model2.cols[col.colName] = col.cnName
    }
    return model2
  }

  // 模块的【后端action】
  const actionId = 166
  const addActionSQL = async () => {
    const reAction = {}
    const item = {
      serviceId: moduleInfo.moduleModal.moduleId, // 模块ID, int
      actionId: 10, // actionID, int
      actionName: '10', // 名称
      kind: 'add', // 操作方式
      model: '10' // 使用的modelID
    }
    // 先检查有没有，没有——添加；有——修改/提示？
    const logIndex = myLog.newLog('后端 action')
    const cols = [
      { actionName: '添加', kind: 'model-add' },
      { actionName: '修改', kind: 'model-update' },
      { actionName: '删除', kind: 'model-delete' },
      { actionName: '获取', kind: 'model-get' },
      { actionName: '查询', kind: 'list-pager' },
      { actionName: '获取全部数据', kind: 'list-all' }
    ]
    for (let index = 0; index < cols.length; index++) {
      const col = cols[index]
      // cols.forEach(async (col, index) => { // 把表的字段都加入表单
      item.actionId = (index + 1) * 10
      item.actionName = col.actionName
      item.kind = col.kind
      const newItem = {}
      Object.assign(newItem, item)
      reAction[item.actionId] = newItem
      myLog.start(col.actionName, logIndex)
      const res = await v_service_action.add(newItem)
      myLog.end(res.newId, logIndex)
    } // )
    return reAction
  }

  /**
   * 先把 meta 存入SQL，然后获取返回值
   * * 再把 meta 加入 indexedDB
   * * 最后存入 state
   */
  const setMeta = async () => {
    const newModuleMeta = {
      moduleId: moduleInfo.moduleModal.moduleId,
      forms: {}
    }
    // 写入 SQL
    newModuleMeta.pager = await addModuleSQL()
    newModuleMeta.button = await addButtonSQL()
    newModuleMeta.find = await addFindSQL()
    newModuleMeta.grid = await addGridSQL()
    newModuleMeta.forms[intModuleId + 10] = await addFormSQL()
    // 写入 indexedDB
    console.log('生成的meta====', newModuleMeta)
    // 设置菜单
    const _menu = {
      id: moduleInfo.moduleModal.moduleId,
      componentKind: moduleInfo.moduleModal.componentKind,
      icon: moduleInfo.moduleModal.icon,
      moduleLevel: moduleInfo.moduleModal.moduleLevel,
      parentId: moduleInfo.moduleModal.parentId,
      title: moduleInfo.moduleModal.title
    }
    // 菜单写入 indexedDB 和 state
    myLog.newLog('菜单写入 indexedDB 和 state')
    await help.addModel('menuMeta', _menu)
    state.projectMeta.menu.push(_menu)
    myLog.end(0)

    // 模块写入indexedDB
    myLog.newLog('模块写入indexedDB')
    await help.addModel('moduleMeta', newModuleMeta)
    myLog.end(0)

    // 模块写入state
    myLog.newLog('模块写入state')
    state.projectMeta.module[newModuleMeta.moduleId] = newModuleMeta
    myLog.end(0)
  }

  // 设置后端API的meta，存入webSQL
  const setAPIMeta = async () => {
    const serviceMeta = {
      moduleId: moduleInfo.moduleModal.moduleId,
      moduleName: '',
      actions: {},
      models: {}
    }

    await addServiceSQL()
    serviceMeta.actions = await addActionSQL()
    serviceMeta.models[10] = await addModelSQL()

    // 服务写入indexedDB
    myLog.newLog('服务写入indexedDB')
    await help.addModel('serviceMeta', serviceMeta)
    myLog.end(0)

    // 模块写入state
    myLog.newLog('服务写入state')
    state.projectMeta.service[moduleInfo.moduleModal.moduleId] = serviceMeta
    myLog.end(0)
  }

  /**
   * 在webSQL里面建立表和演示数据，便于在线演示
   */
  const setDataBase = async () => {
    // const helpSQL = installWebSQL.useHelp(state.dbFlag.project_sql_data)
    const tableName = moduleInfo.tableModal.tableName
    const colunms = {}
    for (let index = 0; index < cols.length; index++) {
      const col = cols[index]
      colunms[col.colName] = index
    }
    // createTable(helpSQL, tableName, colunms).then((res) => {
    //  console.log('建表成功!', res)
    //  // 添加测试数据
    //  addData(helpSQL, { tableName, colunms }, colunms).then((res1) => {
    //    console.log('添加测试数据成功!', res1)
    //  })
    // })
  }

  /**
   * 开始设置meta，存入SQL和indexedDB和state
   */
  const start = async () => {
    // 重新计算
    myLog.clear()
    intTableId = parseInt(moduleInfo.tableModal.tableId) * 1000
    intModuleId = parseInt(moduleInfo.moduleModal.moduleId) * 100
    // 字段meta
    // cols = moduleInfo.columnModal
    // 字段ID集合
    colIds.length = 0
    cols.forEach((col, index) => { // 记录 字段ID
      colIds.push(col.columnId)
    })
    // 开始设置
    await addTableSQL() // 表、字段的 meta，存入webSQL
    await setMeta() // 前端控件的 meta，存入webSQL、indexedDB和state
    await setAPIMeta() // 设置后端API，存入webSQL、indexedDB和state
    await setDataBase() // 建立表和演示数据 webSQL
  }

  return {
    myLog,
    start
  }
}

/**
 * 删除模块的meta信息
 */
const deleteMeta = () => {
  // 进度提示信息
  const info = reactive({
    module: { // 模块菜单
      t1: 0,
      t2: 0,
      msg: ''
    },
    table: { // 表
      t1: 0,
      t2: 0,
      msg: ''
    },
    column: { // 字段
      t1: 0,
      t2: 0,
      msg: ''
    },
    grid: { // 模块的列表
      t1: 0,
      t2: 0,
      msg: ''
    },
    grid_item: { // 模块的列表的字段
      t1: 0,
      t2: 0,
      msg: ''
    },
    form: { // 模块的表单，和按钮对应
      t1: 0,
      t2: 0,
      msg: ''
    },
    form_item: { // 模块的表单的字段
      t1: 0,
      t2: 0,
      msg: ''
    },
    find: { // 模块的查询
      t1: 0,
      t2: 0,
      msg: ''
    },
    find_item: { // 模块的查询的字段
      t1: 0,
      t2: 0,
      msg: ''
    },
    button: { // 模块的操作按钮，添加、修改、删除等
      t1: 0,
      t2: 0,
      msg: ''
    },
    pager: { // 模块的列表的分页
      t1: 0,
      t2: 0,
      msg: ''
    },
    sqlToDB: { // 从 webSQL提取模块meta存入indexedDB
      t1: 0,
      t2: 0,
      msg: ''
    },
    api: { // 后端api
      t1: 0,
      t2: 0,
      msg: ''
    },
    mySQL: { // 后端数据库
      t1: 0,
      t2: 0,
      msg: ''
    },
    webSQL: { // 在线演示
      t1: 0,
      t2: 0,
      msg: ''
    }
  })

  // 【模块】的删除
  const moduleId = 150
  const delMenu = (id) => {
    info.module.msg = '开始删除【模块菜单】...'
    info.module.t1 = window.performance.now()
    nf_module.del(id).then((res) => {
      console.log('删除模块成功，记录数：', res)
      info.module.t2 = window.performance.now()
      info.module.msg = `${info.module.msg.replace('...', '，')}删除成功！记录数：${res.count}。用时：${(info.module.t2 - info.module.t1)}`
    })
  }

  // 【分页】的删除
  const pagerId = 151
  const delPager = (id) => {
    info.pager.msg = '开始删除【模块分页】...'
    info.pager.t1 = window.performance.now()
    v_module_pager.del(id).then((res) => {
      console.log('删除分页成功，记录数：', res)
      info.pager.t2 = window.performance.now()
      info.pager.msg = `${info.pager.msg.replace('...', '，')}删除成功！记录数：${res.count}。用时：${(info.pager.t2 - info.pager.t1)}`
    })
  }

  // 【操作按钮】的删除
  const buttonId = 152
  const delButton = (id) => {
    info.button.msg = '开始删除【操作按钮】...'
    info.button.t1 = window.performance.now()
    v_module_button.del(id).then((res) => {
      console.log('删除操作按钮成功，记录数：', res)
      info.button.t2 = window.performance.now()
      info.button.msg = `${info.button.msg.replace('...', '，')}删除成功！记录数：${res.count}。用时：${(info.button.t2 - info.button.t1)}`
    })
  }

  // 【列表】的删除
  const gridId = 153
  const delGrid = (id) => {
    info.grid.msg = '开始删除【列表】...'
    info.grid.t1 = window.performance.now()
    nf_table.del(id).then((res) => {
      console.log('删除【列表】成功，记录数：', res)
      info.grid.t2 = window.performance.now()
      info.grid.msg = `${info.grid.msg.replace('...', '，')}删除成功！记录数：${res.count}。用时：${(info.grid.t2 - info.grid.t1)}`
    })
  }

  // 【列表字段】的删除
  const gridItemId = 154
  const delGridItem = (id) => {
    info.grid_item.msg = '开始删除【列表字段】...'
    info.grid_item.t1 = window.performance.now()
    nf_table_columns.del(id).then((res) => {
      console.log('删除【列表字段】成功，记录数：', res)
      info.grid_item.t2 = window.performance.now()
      info.grid_item.msg = `${info.grid_item.msg.replace('...', '，')}删除成功！记录数：${res.count}。用时：${(info.grid_item.t2 - info.grid_item.t1)}`
    })
  }

  // 【表单】的删除
  const formId = 158
  const delForm = (id) => {
    info.form.msg = '开始删除【表单】...'
    info.form.t1 = window.performance.now()
    v_module_form.del(id).then((res) => {
      console.log('删除【表单】成功，记录数：', res)
      info.form.t2 = window.performance.now()
      info.form.msg = `${info.form.msg.replace('...', '，')}删除成功！记录数：${res.count}。用时：${(info.form.t2 - info.form.t1)}`
    })
  }

  // 【表单字段】的删除
  const formItemId = 159
  const delFormItem = (id) => {
    info.form_item.msg = '开始删除【表单字段】...'
    info.form_item.t1 = window.performance.now()
    v_module_form_item.del(id).then((res) => {
      console.log('删除【表单字段】成功，记录数：', res)
      info.form_item.t2 = window.performance.now()
      info.form_item.msg = `${info.form_item.msg.replace('...', '，')}删除成功！记录数：${res.count}。用时：${(info.form_item.t2 - info.form_item.t1)}`
    })
  }

  // 【查询】的删除
  const findId = 155
  const delFind = (id) => {
    info.find.msg = '开始删除【查询】...'
    info.find.t1 = window.performance.now()
    v_module_find.del(id).then((res) => {
      console.log('删除【查询】成功，记录数：', res)
      info.find.t2 = window.performance.now()
      info.find.msg = `${info.find.msg.replace('...', '，')}删除成功！记录数：${res.count}。用时：${(info.find.t2 - info.find.t1)}`
    })
  }

  // 【查询字段】的删除
  const findItemId = 156
  const delFindItem = (id) => {
    info.find_item.msg = '开始删除【查询字段】...'
    info.find_item.t1 = window.performance.now()
    v_module_find_item.del(id).then((res) => {
      console.log('删除【查询字段】成功，记录数：', res)
      info.find_item.t2 = window.performance.now()
      info.find_item.msg = `${info.find_item.msg.replace('...', '，')}删除成功！记录数：${res.count}。用时：${(info.find_item.t2 - info.find_item.t1)}`
    })
  }

  const startMeta = (id) => {
    delMenu(id) // 菜单
    delPager(id)
    delButton(id)
    delGrid(id) // 列表
    delGridItem(id)
    delForm(id) // 表单
    delFormItem(id)
    delFind(id) // 查询
    delFindItem(id)
  }

  return {
    infoDelete: info,
    startMeta
  }
}

</script>

<script setup>

const props = defineProps({
  moduleId: [Number, String],
  moduleInfo: Object
})

const {
  myLog,
  start,
  info
} = createMeta(props.moduleInfo)

const {
  infoDelete,
  startMeta
} = deleteMeta()

// 删除模块信息
const metaModuleId = ref(0)
const deletaMeta = () => {
  startMeta(metaModuleId.value)
}

/**
 * 导入数据生成表和字段的信息
 * 可以修改字段类型等信息
 * 往 webSQL 的 meta 里面添加表和字段
 * 如果设置模块ID的话，往 indexedDB 的 meta 里面添加 模块信息
 */

</script>
